package com.playtruly.wanzhende2025

import android.Manifest
import android.content.Context
import android.content.pm.PackageManager
import android.util.Log
import androidx.core.content.ContextCompat
import com.amap.api.location.AMapLocation
import com.amap.api.location.AMapLocationClient
import com.amap.api.location.AMapLocationClientOption
import com.amap.api.location.AMapLocationListener
import com.amap.api.services.core.LatLonPoint
import com.amap.api.services.geocoder.GeocodeSearch
import com.amap.api.services.geocoder.RegeocodeQuery
import com.amap.api.services.geocoder.RegeocodeResult
import com.amap.api.services.geocoder.GeocodeResult
import com.amap.api.services.core.AMapException
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.MethodChannel.MethodCallHandler
import io.flutter.plugin.common.MethodChannel.Result

/**
 * 高德地图定位服务类（学习MyApplication2项目实现）
 * 
 * 功能特性：
 * 1. 高精度定位（与MyApplication2相同配置）
 * 2. 单次定位和持续定位
 * 3. 逆地理编码（坐标转地址）
 * 4. 错误处理和状态管理
 * 5. Platform Channel通信
 */
class AmapLocationService(private val context: Context) : MethodCallHandler, AMapLocationListener, GeocodeSearch.OnGeocodeSearchListener {
    
    companion object {
        private const val TAG = "AmapLocationService"
        const val CHANNEL_NAME = "com.playtruly.amap_location"
        
        // 定位结果状态码
        private const val SUCCESS = 0
        private const val ERROR_PERMISSION_DENIED = 12
        private const val ERROR_NETWORK = 4
        private const val ERROR_UNKNOWN = -1
    }
    
    // 高德定位客户端
    private var locationClient: AMapLocationClient? = null
    private var isLocationStarted = false
    
    // Flutter通信结果回调
    private var pendingResult: Result? = null
    
    // 逆地理编码相关
    private var geocodeSearch: GeocodeSearch? = null
    private var pendingGeocodeResult: Result? = null
    
    // 当前逆地理编码的坐标
    private var currentGeocodeLatitude: Double = 0.0
    private var currentGeocodeLongitude: Double = 0.0
    
    /**
     * 初始化高德定位客户端（学习MyApplication2的配置）
     */
    private fun initLocationClient() {
        try {
            if (locationClient == null) {
                Log.d(TAG, "🎯 =============== 初始化高德定位客户端 ===============")
                
                // 🗺️ 确保隐私合规设置已生效（双重保险）
                ensurePrivacyCompliance()
                
                // ⏰ 延迟一下确保隐私设置完全生效（重要！）
                Log.d(TAG, "⏰ 等待隐私设置生效...")
                Thread.sleep(100) // 等待100ms确保隐私设置生效
                
                Log.d(TAG, "🚀 开始创建 AMapLocationClient...")
                Log.d(TAG, "📍 使用上下文: ${context.applicationContext}")
                
                // 初始化定位客户端
                locationClient = AMapLocationClient(context.applicationContext)
                Log.d(TAG, "✅ AMapLocationClient 创建成功")
                
                // 设置定位监听
                locationClient?.setLocationListener(this)
                Log.d(TAG, "✅ 定位监听器设置成功")
                
                // 🌐 初始化逆地理编码搜索服务
                initGeocodeSearch()
                
                Log.d(TAG, "🎉 高德定位客户端初始化完全成功")
                Log.d(TAG, "🎯 =============== 定位客户端初始化结束 ===============")
            } else {
                Log.d(TAG, "ℹ️ 定位客户端已存在，跳过初始化")
            }
        } catch (e: Exception) {
            Log.e(TAG, "💥 高德定位客户端初始化失败: ${e.message}", e)
            Log.e(TAG, "💥 异常类型: ${e.javaClass.simpleName}")
            Log.e(TAG, "💥 完整堆栈: ", e)
            
            // 🔄 清空失败的客户端，为下次重试做准备
            locationClient = null
        }
    }
    
    /**
     * 🌐 初始化逆地理编码搜索服务
     */
    private fun initGeocodeSearch() {
        try {
            if (geocodeSearch == null) {
                Log.d(TAG, "🌐 =============== 初始化逆地理编码搜索服务 ===============")
                
                geocodeSearch = GeocodeSearch(context.applicationContext)
                geocodeSearch?.setOnGeocodeSearchListener(this)
                
                Log.d(TAG, "✅ 逆地理编码搜索服务初始化成功")
                Log.d(TAG, "🌐 =============== 逆地理编码搜索服务初始化结束 ===============")
            } else {
                Log.d(TAG, "ℹ️ 逆地理编码搜索服务已存在，跳过初始化")
            }
        } catch (e: Exception) {
            Log.e(TAG, "💥 逆地理编码搜索服务初始化失败: ${e.message}", e)
            geocodeSearch = null
        }
    }
    
    /**
     * 🗺️ 确保隐私合规设置（强化版本 - 多重保险）
     * 
     * 使用多种方法确保隐私合规设置一定生效
     * 避免因为时序问题导致隐私合规校验失败（错误码555570）
     */
    private fun ensurePrivacyCompliance() {
        try {
            Log.d(TAG, "🔍 =============== 强制隐私合规设置（强化版）===============")
            Log.d(TAG, "📍 当前上下文: ${context.applicationContext}")
            Log.d(TAG, "📍 上下文类型: ${context.applicationContext.javaClass.simpleName}")
            
            // 🔄 方法1: 使用Application上下文
            Log.d(TAG, "🔑 方法1: 使用Application上下文设置隐私合规...")
            try {
                AMapLocationClient.updatePrivacyShow(context.applicationContext, true, true)
                AMapLocationClient.updatePrivacyAgree(context.applicationContext, true)
                Log.d(TAG, "✅ 方法1成功")
            } catch (e: Exception) {
                Log.e(TAG, "❌ 方法1失败: ${e.message}")
            }
            
            // 🔄 方法2: 使用当前上下文
            Log.d(TAG, "🔑 方法2: 使用当前上下文设置隐私合规...")
            try {
                AMapLocationClient.updatePrivacyShow(context, true, true)
                AMapLocationClient.updatePrivacyAgree(context, true)
                Log.d(TAG, "✅ 方法2成功")
            } catch (e: Exception) {
                Log.e(TAG, "❌ 方法2失败: ${e.message}")
            }
            
            // ⏰ 添加延时确保设置生效
            Log.d(TAG, "⏰ 等待50ms确保隐私设置生效...")
            Thread.sleep(50)
            
            // 🔄 方法3: 再次强制设置（多次调用确保生效）
            Log.d(TAG, "🔑 方法3: 再次强制设置隐私合规...")
            for (i in 1..3) {
                try {
                    Log.d(TAG, "🔄 第${i}次设置隐私合规...")
                    AMapLocationClient.updatePrivacyShow(context.applicationContext, true, true)
                    AMapLocationClient.updatePrivacyAgree(context.applicationContext, true)
                    Log.d(TAG, "✅ 第${i}次设置成功")
                    Thread.sleep(20) // 短暂等待
                } catch (e: Exception) {
                    Log.e(TAG, "❌ 第${i}次设置失败: ${e.message}")
                }
            }
            
            Log.d(TAG, "🎉 隐私合规设置强化完成")
            Log.d(TAG, "🔍 =============== 隐私合规设置结束 ===============")
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 隐私合规设置强化失败: ${e.message}", e)
            Log.e(TAG, "💥 异常类型: ${e.javaClass.simpleName}")
            Log.e(TAG, "💥 完整堆栈: ", e)
        }
    }
    
    /**
     * 创建定位选项（学习MyApplication2的高精度配置）
     */
    private fun createLocationOption(onceLocation: Boolean = true): AMapLocationClientOption {
        return AMapLocationClientOption().apply {
            // 设置定位模式为高精度模式（与MyApplication2相同）
            locationMode = AMapLocationClientOption.AMapLocationMode.Hight_Accuracy
            
            // 设置定位场景为签到场景（与MyApplication2相同）
            locationPurpose = AMapLocationClientOption.AMapLocationPurpose.SignIn
            
            // 是否返回地址信息
            isNeedAddress = true
            
            // 是否只定位一次
            isOnceLocation = onceLocation
            
            // 🔥 传入true，启动定位，会将最近3s内精度最高的一次定位结果（与MyApplication2相同）
            if (onceLocation) {
                isOnceLocationLatest = true
            }
            
            // 设置定位间隔（持续定位时使用）
            if (!onceLocation) {
                interval = 2000 // 2秒间隔
            }
            
            // 设置是否允许模拟位置
            isMockEnable = false
            
            // 设置是否允许WiFi扫描
            isWifiScan = true
            
            // 🔥 禁用缓存策略（与MyApplication2相同）
            isLocationCacheEnable = false
            
            // 设置网络请求超时时间
            httpTimeOut = 30000 // 30秒
            
            Log.d(TAG, "📋 定位选项配置完成: 高精度模式, 单次定位=$onceLocation")
        }
    }
    
    /**
     * 检查定位权限（学习MyApplication2的权限检查逻辑）
     */
    private fun checkLocationPermissions(): Boolean {
        try {
            Log.d(TAG, "🔍 =============== 检查定位权限 ===============")
            
            val requiredPermissions = arrayOf(
                Manifest.permission.ACCESS_COARSE_LOCATION,
                Manifest.permission.ACCESS_FINE_LOCATION
            )
            
            var allPermissionsGranted = true
            for (permission in requiredPermissions) {
                val result = ContextCompat.checkSelfPermission(context, permission)
                Log.d(TAG, "📋 权限检查: $permission = ${if (result == PackageManager.PERMISSION_GRANTED) "已授权" else "未授权"}")
                
                if (result != PackageManager.PERMISSION_GRANTED) {
                    allPermissionsGranted = false
                }
            }
            
            Log.d(TAG, "🔍 权限检查结果: ${if (allPermissionsGranted) "✅ 全部权限已授权" else "❌ 缺少权限"}")
            Log.d(TAG, "🔍 =============== 权限检查结束 ===============")
            
            return allPermissionsGranted
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 权限检查异常: ${e.message}", e)
            return false
        }
    }

    /**
     * 开始定位
     */
    private fun startLocation(isOnceLocation: Boolean = true) {
        try {
            Log.d(TAG, "🎯 =============== 开始高德定位 ===============")
            Log.d(TAG, "📍 定位模式: ${if (isOnceLocation) "单次定位" else "持续定位"}")
            
            // 🔒 首先检查权限（学习MyApplication2的权限检查）
            if (!checkLocationPermissions()) {
                Log.e(TAG, "❌ 定位权限检查失败，无法开始定位")
                handleLocationError(ERROR_PERMISSION_DENIED, "缺少定位权限，请在应用设置中授予位置权限")
                return
            }
            
            Log.d(TAG, "✅ 权限检查通过，继续初始化定位客户端")
            
            // 初始化定位客户端
            initLocationClient()
            
            val locationClient = this.locationClient
            if (locationClient == null) {
                Log.e(TAG, "❌ 定位客户端为空，无法开始定位")
                handleLocationError(ERROR_UNKNOWN, "定位客户端初始化失败")
                return
            }
            
            // 设置定位参数
            val locationOption = createLocationOption(isOnceLocation)
            locationClient.setLocationOption(locationOption)
            
            // 🔥 设置场景模式后最好调用一次stop，再调用start以保证场景模式生效（与MyApplication2相同）
            locationClient.stopLocation()
            
            // 开始定位
            locationClient.startLocation()
            isLocationStarted = true
            
            Log.d(TAG, "🚀 高德定位已启动")
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 开始定位异常: ${e.message}", e)
            handleLocationError(ERROR_UNKNOWN, "定位启动异常: ${e.message}")
        }
    }
    
    /**
     * 停止定位
     */
    private fun stopLocation() {
        try {
            locationClient?.let { client ->
                if (isLocationStarted) {
                    client.stopLocation()
                    isLocationStarted = false
                    Log.d(TAG, "🛑 高德定位已停止")
                }
            }
        } catch (e: Exception) {
            Log.e(TAG, "💥 停止定位异常: ${e.message}", e)
        }
    }
    
    /**
     * 销毁定位客户端
     */
    fun destroy() {
        try {
            stopLocation()
            locationClient?.onDestroy()
            locationClient = null
            pendingResult = null
            Log.d(TAG, "🗑️ 高德定位服务已销毁")
        } catch (e: Exception) {
            Log.e(TAG, "💥 销毁定位服务异常: ${e.message}", e)
        }
    }
    
    /**
     * 定位回调监听（学习MyApplication2的处理逻辑）
     */
    override fun onLocationChanged(location: AMapLocation?) {
        try {
            Log.d(TAG, "📍 =============== 定位回调触发 ===============")
            
            if (location != null) {
                val errorCode = location.errorCode
                Log.d(TAG, "📊 定位结果状态码: $errorCode")
                
                if (errorCode == SUCCESS) {
                    // 定位成功
                    handleLocationSuccess(location)
                } else {
                    // 定位失败
                    val errorInfo = location.errorInfo ?: "未知错误"
                    Log.e(TAG, "❌ 定位失败: errorCode=$errorCode, errorInfo=$errorInfo")
                    handleLocationError(errorCode, errorInfo)
                }
            } else {
                Log.e(TAG, "❌ 定位结果为空")
                handleLocationError(ERROR_UNKNOWN, "定位结果为空")
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 定位回调处理异常: ${e.message}", e)
            handleLocationError(ERROR_UNKNOWN, "定位回调异常: ${e.message}")
        } finally {
            Log.d(TAG, "🏁 =============== 定位回调处理完成 ===============")
        }
    }
    
    /**
     * 处理定位成功结果
     */
    private fun handleLocationSuccess(location: AMapLocation) {
        try {
            // 🔧 使用HashMap<String, Any?>确保类型兼容性（学习MyApplication2的数据格式）
            val result = HashMap<String, Any?>()
            
            // 基本位置信息
            result["success"] = true
            result["latitude"] = location.latitude
            result["longitude"] = location.longitude
            result["accuracy"] = location.accuracy.toDouble()
            result["altitude"] = location.altitude
            result["bearing"] = location.bearing.toDouble()
            result["speed"] = location.speed.toDouble()
            result["timestamp"] = location.time
            
            // 地址信息（确保不为null）
            result["address"] = location.address ?: ""
            result["country"] = location.country ?: ""
            result["province"] = location.province ?: ""
            result["city"] = location.city ?: ""
            result["district"] = location.district ?: ""
            result["street"] = location.street ?: ""
            result["streetNumber"] = location.streetNum ?: ""
            result["poiName"] = location.poiName ?: ""
            result["aoiName"] = location.aoiName ?: ""
            
            // 定位提供者信息
            result["provider"] = location.provider ?: ""
            result["locationType"] = location.locationType
            
            // 错误码和消息（成功时为null）
            result["errorCode"] = null
            result["errorMessage"] = null
            
            // 调试信息输出
            Log.d(TAG, "✅ 定位成功!")
            Log.d(TAG, "📍 坐标: ${location.latitude}, ${location.longitude}")
            Log.d(TAG, "🎯 精度: ${location.accuracy}m")
            Log.d(TAG, "📍 地址: ${location.address}")
            Log.d(TAG, "🏙️ 城市: ${location.province} ${location.city} ${location.district}")
            Log.d(TAG, "🛣️ 街道: ${location.street} ${location.streetNum}")
            Log.d(TAG, "📡 定位类型: ${location.locationType}")
            Log.d(TAG, "🔧 提供者: ${location.provider}")
            
            // 返回结果到Flutter
            pendingResult?.success(result)
            pendingResult = null
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 处理定位成功结果异常: ${e.message}", e)
            handleLocationError(ERROR_UNKNOWN, "处理定位结果异常: ${e.message}")
        }
    }
    
    /**
     * 处理定位错误
     */
    private fun handleLocationError(errorCode: Int, errorMessage: String) {
        try {
            // 🔧 使用HashMap<String, Any?>确保类型兼容性
            val result = HashMap<String, Any?>()
            
            // 基本状态信息
            result["success"] = false
            result["errorCode"] = errorCode
            result["errorMessage"] = errorMessage
            
            // 位置信息设为null
            result["latitude"] = null
            result["longitude"] = null
            result["accuracy"] = null
            result["altitude"] = null
            result["bearing"] = null
            result["speed"] = null
            result["timestamp"] = null
            
            // 地址信息设为null
            result["address"] = null
            result["country"] = null
            result["province"] = null
            result["city"] = null
            result["district"] = null
            result["street"] = null
            result["streetNumber"] = null
            result["poiName"] = null
            result["aoiName"] = null
            
            // 定位提供者信息设为null
            result["provider"] = null
            result["locationType"] = null
            
            Log.e(TAG, "❌ 定位失败: errorCode=$errorCode, message=$errorMessage")
            
            // 返回错误结果到Flutter
            pendingResult?.success(result)
            pendingResult = null
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 处理定位错误异常: ${e.message}", e)
            pendingResult?.error("LOCATION_ERROR", "处理定位错误异常: ${e.message}", null)
            pendingResult = null
        }
    }
    
    /**
     * Platform Channel方法调用处理
     */
    override fun onMethodCall(call: MethodCall, result: Result) {
        try {
            Log.d(TAG, "📞 收到方法调用: ${call.method}")
            
            when (call.method) {
                "startLocation" -> {
                    // 如果有待处理的请求，先返回错误
                    if (pendingResult != null) {
                        result.error("LOCATION_IN_PROGRESS", "定位请求正在进行中", null)
                        return
                    }
                    
                    pendingResult = result
                    val isOnceLocation = call.argument<Boolean>("isOnceLocation") ?: true
                    startLocation(isOnceLocation)
                }
                
                "stopLocation" -> {
                    stopLocation()
                    result.success(mapOf("success" to true, "message" to "定位已停止"))
                }
                
                "isLocationStarted" -> {
                    result.success(mapOf("isStarted" to isLocationStarted))
                }
                
                "checkPermissions" -> {
                    Log.d(TAG, "🔍 执行权限检查方法...")
                    val hasPermissions = checkLocationPermissions()
                    Log.d(TAG, "📋 权限检查结果: $hasPermissions")
                    result.success(mapOf(
                        "hasPermissions" to hasPermissions,
                        "message" to if (hasPermissions) "定位权限已授权" else "缺少定位权限，请在应用设置中授予位置权限"
                    ))
                }
                
                "requestPermissions" -> {
                    Log.d(TAG, "🔒 请求定位权限...")
                    // 注意：在Flutter应用中，权限请求应该通过Flutter端的权限插件处理
                    // 这里只返回当前权限状态
                    val hasPermissions = checkLocationPermissions()
                    result.success(mapOf(
                        "hasPermissions" to hasPermissions,
                        "message" to if (hasPermissions) "定位权限已授权" else "请在Flutter端使用权限插件请求权限"
                    ))
                }
                
                "reverseGeocode" -> {
                    // 如果有待处理的逆地理编码请求，先返回错误
                    if (pendingGeocodeResult != null) {
                        result.error("GEOCODE_IN_PROGRESS", "逆地理编码请求正在进行中", null)
                        return
                    }
                    
                    val latitude = call.argument<Double>("latitude")
                    val longitude = call.argument<Double>("longitude")
                    
                    if (latitude == null || longitude == null) {
                        result.error("INVALID_ARGUMENTS", "缺少latitude或longitude参数", null)
                        return
                    }
                    
                    pendingGeocodeResult = result
                    startReverseGeocode(latitude, longitude)
                }
                
                else -> {
                    Log.w(TAG, "⚠️ 未知方法调用: ${call.method}")
                    result.notImplemented()
                }
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 方法调用处理异常: ${e.message}", e)
            result.error("METHOD_CALL_ERROR", "方法调用异常: ${e.message}", null)
        }
    }
    
    /**
     * 🌐 开始逆地理编码
     */
    private fun startReverseGeocode(latitude: Double, longitude: Double) {
        try {
            Log.d(TAG, "🌐 =============== 开始逆地理编码 ===============")
            Log.d(TAG, "📍 目标坐标: $latitude, $longitude")
            
            // 🎯 存储当前坐标，供回调使用
            currentGeocodeLatitude = latitude
            currentGeocodeLongitude = longitude
            
            // 检查权限
            if (!checkLocationPermissions()) {
                Log.e(TAG, "❌ 逆地理编码权限检查失败")
                handleGeocodeError("缺少定位权限，无法进行逆地理编码")
                return
            }
            
            // 初始化GeocodeSearch（如果还没初始化）
            if (geocodeSearch == null) {
                initGeocodeSearch()
            }
            
            if (geocodeSearch == null) {
                Log.e(TAG, "❌ GeocodeSearch初始化失败")
                handleGeocodeError("逆地理编码服务初始化失败")
                return
            }
            
            // 创建逆地理编码查询
            val latLonPoint = LatLonPoint(latitude, longitude)
            val query = RegeocodeQuery(latLonPoint, 200f, GeocodeSearch.AMAP)
            
            Log.d(TAG, "📞 调用高德逆地理编码API...")
            geocodeSearch?.getFromLocationAsyn(query)
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 逆地理编码异常: ${e.message}", e)
            handleGeocodeError("逆地理编码异常: ${e.message}")
        }
    }
    
    /**
     * 🌐 逆地理编码成功回调
     */
    override fun onRegeocodeSearched(result: RegeocodeResult?, rCode: Int) {
        try {
            Log.d(TAG, "🌐 =============== 逆地理编码回调 ===============")
            Log.d(TAG, "📊 返回码: $rCode")
            
            if (rCode == AMapException.CODE_AMAP_SUCCESS) {
                if (result?.regeocodeAddress != null) {
                    val address = result.regeocodeAddress
                    Log.d(TAG, "✅ 逆地理编码成功!")
                    
                    // 构建详细结果（和定位结果格式保持一致）
                    val geocodeResult = HashMap<String, Any?>()
                    
                    // 基本成功标识
                    geocodeResult["success"] = true
                    geocodeResult["latitude"] = currentGeocodeLatitude
                    geocodeResult["longitude"] = currentGeocodeLongitude
                    
                    // 详细地址信息
                    geocodeResult["address"] = address.formatAddress ?: ""
                    geocodeResult["country"] = address.country ?: ""
                    geocodeResult["province"] = address.province ?: ""
                    geocodeResult["city"] = address.city ?: ""
                    geocodeResult["district"] = address.district ?: ""
                    geocodeResult["street"] = address.township ?: ""
                    geocodeResult["streetNumber"] = address.streetNumber?.number ?: ""
                    geocodeResult["poiName"] = address.businessAreas?.firstOrNull()?.name ?: ""
                    geocodeResult["aoiName"] = address.aois?.firstOrNull()?.aoiName ?: ""
                    
                    // 其他字段设置为默认值
                    geocodeResult["accuracy"] = 0.0
                    geocodeResult["altitude"] = 0.0
                    geocodeResult["bearing"] = 0.0
                    geocodeResult["speed"] = 0.0
                    geocodeResult["timestamp"] = System.currentTimeMillis()
                    geocodeResult["provider"] = "amap_geocode"
                    geocodeResult["locationType"] = 0
                    geocodeResult["errorCode"] = null
                    geocodeResult["errorMessage"] = null
                    
                    Log.d(TAG, "📍 详细地址: ${address.formatAddress}")
                    Log.d(TAG, "🏙️ 行政区域: ${address.province} ${address.city} ${address.district}")
                    
                    // 返回结果给Flutter
                    pendingGeocodeResult?.success(geocodeResult)
                } else {
                    Log.e(TAG, "❌ 逆地理编码结果为空")
                    handleGeocodeError("逆地理编码结果为空")
                }
            } else {
                val errorMessage = when (rCode) {
                    AMapException.CODE_AMAP_CLIENT_NETWORK_EXCEPTION -> "网络异常"
                    AMapException.CODE_AMAP_CLIENT_UNKNOWN_ERROR -> "未知错误"
                    AMapException.CODE_AMAP_SERVICE_UNKNOWN_ERROR -> "服务端未知错误"
                    else -> "逆地理编码失败，错误码: $rCode"
                }
                Log.e(TAG, "❌ 逆地理编码失败: $errorMessage")
                handleGeocodeError(errorMessage)
            }
            
        } catch (e: Exception) {
            Log.e(TAG, "💥 逆地理编码回调异常: ${e.message}", e)
            handleGeocodeError("逆地理编码回调异常: ${e.message}")
        } finally {
            pendingGeocodeResult = null
            Log.d(TAG, "🌐 =============== 逆地理编码回调处理完成 ===============")
        }
    }
    
    /**
     * 🌐 地理编码成功回调（正向地理编码，暂不实现）
     */
    override fun onGeocodeSearched(result: GeocodeResult?, rCode: Int) {
        // 暂不需要实现正向地理编码
        Log.d(TAG, "onGeocodeSearched called, but not implemented")
    }
    
    /**
     * 处理逆地理编码错误
     */
    private fun handleGeocodeError(errorMessage: String) {
        try {
            val errorResult = HashMap<String, Any?>()
            errorResult["success"] = false
            errorResult["errorCode"] = -1
            errorResult["errorMessage"] = errorMessage
            
            // 其他字段设置为null
            errorResult["latitude"] = null
            errorResult["longitude"] = null
            errorResult["address"] = null
            errorResult["country"] = null
            errorResult["province"] = null
            errorResult["city"] = null
            errorResult["district"] = null
            errorResult["street"] = null
            errorResult["streetNumber"] = null
            errorResult["poiName"] = null
            errorResult["aoiName"] = null
            errorResult["accuracy"] = null
            errorResult["altitude"] = null
            errorResult["bearing"] = null
            errorResult["speed"] = null
            errorResult["timestamp"] = null
            errorResult["provider"] = null
            errorResult["locationType"] = null
            
            pendingGeocodeResult?.success(errorResult)
        } catch (e: Exception) {
            Log.e(TAG, "💥 处理逆地理编码错误异常: ${e.message}", e)
            pendingGeocodeResult?.error("GEOCODE_ERROR", errorMessage, null)
        } finally {
            pendingGeocodeResult = null
        }
    }
}
